રેગ્યુલર એક્સપ્રેશન ઓપ્ટિમાઇઝેશન: રેજેક્સ પર્ફોર્મન્સ ટ્યુનિંગમાં ઊંડાણપૂર્વકનો અભ્યાસ

રેગ્યુલર એક્સપ્રેશન, અથવા રેજેક્સ, આધુનિક પ્રોગ્રામરની ટૂલકિટમાં એક અનિવાર્ય સાધન છે. વપરાશકર્તાના ઇનપુટને માન્ય કરવા અને લોગ ફાઇલોને પાર્સ કરવાથી માંડીને અત્યાધુનિક સર્ચ-એન્ડ-રિપ્લેસ ઓપરેશન્સ અને ડેટા એક્સટ્રેક્શન સુધી, તેમની શક્તિ અને વૈવિધ્યતા નિર્વિવાદ છે. જોકે, આ શક્તિ એક છુપી કિંમત સાથે આવે છે. ખરાબ રીતે લખાયેલ રેજેક્સ એક સાયલન્ટ પર્ફોર્મન્સ કિલર બની શકે છે, જે નોંધપાત્ર લેટન્સી લાવે છે, CPU સ્પાઇક્સનું કારણ બને છે, અને સૌથી ખરાબ કિસ્સાઓમાં, તમારી એપ્લિકેશનને અટકાવી દે છે. આ તે સ્થાન છે જ્યાં રેગ્યુલર એક્સપ્રેશન ઓપ્ટિમાઇઝેશન માત્ર 'હોય તો સારું' કૌશલ્ય નહીં, પરંતુ મજબૂત અને માપી શકાય તેવા સોફ્ટવેર બનાવવા માટે એક નિર્ણાયક કૌશલ્ય બની જાય છે.

આ વ્યાપક માર્ગદર્શિકા તમને રેજેક્સ પર્ફોર્મન્સની દુનિયામાં ઊંડાણપૂર્વક લઈ જશે. આપણે જાણીશું કે શા માટે એક દેખીતી રીતે સરળ પેટર્ન વિનાશક રીતે ધીમી હોઈ શકે છે, રેજેક્સ એન્જિન્સની આંતરિક કામગીરીને સમજીશું, અને તમને એવા સિદ્ધાંતો અને તકનીકોનો શક્તિશાળી સમૂહ પૂરો પાડીશું જેથી તમે એવા રેગ્યુલર એક્સપ્રેશન્સ લખી શકો જે માત્ર સાચા જ નહીં, પણ અત્યંત ઝડપી પણ હોય.

'શા માટે' તે સમજવું: ખરાબ રેજેક્સની કિંમત

આપણે ઓપ્ટિમાઇઝેશન તકનીકોમાં જઈએ તે પહેલાં, આપણે જે સમસ્યાને હલ કરવાનો પ્રયાસ કરી રહ્યા છીએ તે સમજવું મહત્ત્વપૂર્ણ છે. રેગ્યુલર એક્સપ્રેશન સાથે સંકળાયેલી સૌથી ગંભીર પર્ફોર્મન્સ સમસ્યા કેટાસ્ટ્રોફિક બેકટ્રેકિંગ (Catastrophic Backtracking) તરીકે ઓળખાય છે, જે એક એવી સ્થિતિ છે જે રેગ્યુલર એક્સપ્રેશન ડિનાયલ ઓફ સર્વિસ (ReDoS) વલ્નરેબિલિટી તરફ દોરી શકે છે.

કેટાસ્ટ્રોફિક બેકટ્રેકિંગ શું છે?

કેટાસ્ટ્રોફિક બેકટ્રેકિંગ ત્યારે થાય છે જ્યારે રેજેક્સ એન્જિન મેચ શોધવા (અથવા કોઈ મેચ શક્ય નથી તે નક્કી કરવા) માટે અપવાદરૂપે લાંબો સમય લે છે. આ વિશિષ્ટ પ્રકારની પેટર્ન્સ અને વિશિષ્ટ પ્રકારના ઇનપુટ સ્ટ્રિંગ્સ સાથે થાય છે. એન્જિન પેટર્નને સંતોષવા માટે દરેક સંભવિત માર્ગનો પ્રયાસ કરતાં, પરિવર્તનોની એક ચક્કર લગાવતી ભુલભુલામણીમાં ફસાઈ જાય છે. ઇનપુટ સ્ટ્રિંગની લંબાઈ સાથે સ્ટેપ્સની સંખ્યા ઘાતાંકીય રીતે વધી શકે છે, જે એપ્લિકેશન ફ્રીઝ જેવી સ્થિતિ તરફ દોરી જાય છે.

એક નબળા રેજેક્સનું આ ક્લાસિક ઉદાહરણ ધ્યાનમાં લો: ^(a+)+$

આ પેટર્ન પૂરતી સરળ લાગે છે: તે એક કે તેથી વધુ 'a' થી બનેલી સ્ટ્રિંગ શોધે છે. તે "a", "aa", અને "aaaaa" જેવી સ્ટ્રિંગ્સ માટે સંપૂર્ણ રીતે કામ કરે છે. સમસ્યા ત્યારે ઊભી થાય છે જ્યારે આપણે તેને એવી સ્ટ્રિંગ સામે ચકાસીએ છીએ જે લગભગ મેચ થાય છે પરંતુ અંતે નિષ્ફળ જાય છે, જેમ કે "aaaaaaaaaaaaaaaaaaaaaaaaaaab".

તે આટલું ધીમું કેમ છે તે અહીં છે:

• બાહ્ય (...)+ અને આંતરિક a+ બંને ગ્રીડી (greedy) ક્વોન્ટિફાયર છે.
• આંતરિક a+ પહેલા બધા 27 'a' ને મેચ કરે છે.
• બાહ્ય (...)+ આ એક મેચથી સંતુષ્ટ છે.
• પછી એન્જિન સ્ટ્રિંગના અંતના એન્કર $ ને મેચ કરવાનો પ્રયાસ કરે છે. તે નિષ્ફળ જાય છે કારણ કે ત્યાં 'b' છે.
• હવે, એન્જિને બેકટ્રેક (backtrack) કરવું પડશે. બાહ્ય જૂથ એક અક્ષર છોડી દે છે, તેથી આંતરિક a+ હવે 26 'a' ને મેચ કરે છે, અને બાહ્ય જૂથનું બીજું પુનરાવર્તન છેલ્લા 'a' ને મેચ કરવાનો પ્રયાસ કરે છે. આ પણ 'b' પર નિષ્ફળ જાય છે.
• એન્જિન હવે આંતરિક a+ અને બાહ્ય (...)+ વચ્ચે 'a' ની સ્ટ્રિંગને વિભાજીત કરવાના દરેક સંભવિત માર્ગનો પ્રયાસ કરશે. N 'a' ની સ્ટ્રિંગ માટે, તેને વિભાજીત કરવાની 2^N-1 રીતો છે. જટિલતા ઘાતાંકીય છે, અને પ્રોસેસિંગ સમય આસમાને પહોંચે છે.

આ એકમાત્ર, દેખીતી રીતે નિર્દોષ રેજેક્સ, સેકંડ, મિનિટો અથવા તેનાથી પણ વધુ સમય માટે CPU કોરને લોક કરી શકે છે, જે અન્ય પ્રક્રિયાઓ અથવા વપરાશકર્તાઓને અસરકારક રીતે સેવા નકારી દે છે.

મુદ્દાનું હાર્દ: રેજેક્સ એન્જિન

રેજેક્સને ઓપ્ટિમાઇઝ કરવા માટે, તમારે સમજવું જ પડશે કે એન્જિન તમારી પેટર્નને કેવી રીતે પ્રોસેસ કરે છે. રેજેક્સ એન્જિન્સના બે મુખ્ય પ્રકારો છે, અને તેમની આંતરિક કામગીરી પર્ફોર્મન્સની લાક્ષણિકતાઓ નક્કી કરે છે.

DFA (Deterministic Finite Automaton) એન્જિન્સ

DFA એન્જિન્સ રેજેક્સની દુનિયાના સ્પીડ ડેમન્સ (ઝડપી રાક્ષસો) છે. તેઓ ઇનપુટ સ્ટ્રિંગને ડાબેથી જમણે, અક્ષર-દર-અક્ષર, એક જ પાસમાં પ્રોસેસ કરે છે. કોઈપણ સમયે, DFA એન્જિન વર્તમાન અક્ષરના આધારે બરાબર જાણે છે કે આગલી સ્થિતિ શું હશે. આનો અર્થ એ છે કે તેને ક્યારેય બેકટ્રેક કરવાની જરૂર નથી. પ્રોસેસિંગ સમય રેખીય છે અને સીધો ઇનપુટ સ્ટ્રિંગની લંબાઈના પ્રમાણસર છે. DFA-આધારિત એન્જિન્સનો ઉપયોગ કરતા સાધનોના ઉદાહરણોમાં grep અને awk જેવા પરંપરાગત Unix ટૂલ્સનો સમાવેશ થાય છે.

ફાયદા: અત્યંત ઝડપી અને અનુમાનિત પર્ફોર્મન્સ. કેટાસ્ટ્રોફિક બેકટ્રેકિંગથી મુક્ત.

ગેરફાયદા: મર્યાદિત ફીચર સેટ. તેઓ બેકરેફરન્સ, લુકઅરાઉન્ડ્સ અથવા કેપ્ચરિંગ ગ્રુપ્સ જેવી એડવાન્સ સુવિધાઓને સપોર્ટ કરતા નથી, જે બેકટ્રેક કરવાની ક્ષમતા પર આધાર રાખે છે.

NFA (Nondeterministic Finite Automaton) એન્જિન્સ

NFA એન્જિન્સ આધુનિક પ્રોગ્રામિંગ ભાષાઓ જેવી કે Python, JavaScript, Java, C# (.NET), Ruby, PHP, અને Perl માં વપરાતો સૌથી સામાન્ય પ્રકાર છે. તેઓ "પેટર્ન-ડ્રાઇવન" છે, જેનો અર્થ છે કે એન્જિન પેટર્નને અનુસરે છે, અને જેમ જેમ તે આગળ વધે છે તેમ તેમ સ્ટ્રિંગમાં આગળ વધે છે. જ્યારે તે અસ્પષ્ટતાના બિંદુ પર પહોંચે છે (જેમ કે વૈકલ્પિક | અથવા ક્વોન્ટિફાયર *, +), ત્યારે તે એક માર્ગનો પ્રયાસ કરશે. જો તે માર્ગ અંતે નિષ્ફળ જાય, તો તે છેલ્લા નિર્ણય બિંદુ પર બેકટ્રેક (backtracks) કરે છે અને આગામી ઉપલબ્ધ માર્ગનો પ્રયાસ કરે છે.

આ બેકટ્રેકિંગ ક્ષમતા જ NFA એન્જિન્સને એટલા શક્તિશાળી અને ફીચર-સમૃદ્ધ બનાવે છે, જે લુકઅરાઉન્ડ્સ અને બેકરેફરન્સ સાથે જટિલ પેટર્ન્સને સક્ષમ કરે છે. જોકે, તે તેમની સૌથી મોટી નબળાઈ પણ છે, કારણ કે તે જ મિકેનિઝમ છે જે કેટાસ્ટ્રોફિક બેકટ્રેકિંગને સક્ષમ કરે છે.

આ માર્ગદર્શિકાના બાકીના ભાગ માટે, અમારી ઓપ્ટિમાઇઝેશન તકનીકો NFA એન્જિનને કાબૂમાં લેવા પર ધ્યાન કેન્દ્રિત કરશે, કારણ કે આ તે સ્થાન છે જ્યાં વિકાસકર્તાઓને મોટાભાગે પર્ફોર્મન્સ સમસ્યાઓનો સામનો કરવો પડે છે.

NFA એન્જિન્સ માટેના મુખ્ય ઓપ્ટિમાઇઝેશન સિદ્ધાંતો

હવે, ચાલો તે વ્યવહારુ, કાર્યક્ષમ તકનીકોમાં ઊંડા ઉતરીએ જેનો ઉપયોગ તમે ઉચ્ચ-પર્ફોર્મન્સ રેગ્યુલર એક્સપ્રેશન્સ લખવા માટે કરી શકો છો.

1. વિશિષ્ટ બનો: ચોકસાઈની શક્તિ

સૌથી સામાન્ય પર્ફોર્મન્સ એન્ટિ-પેટર્ન .* જેવા અતિશય સામાન્ય વાઇલ્ડકાર્ડ્સનો ઉપયોગ કરવો છે. ડોટ . (લગભગ) કોઈપણ અક્ષરને મેચ કરે છે, અને એસ્ટરિસ્ક * નો અર્થ "શૂન્ય કે તેથી વધુ વખત" છે. જ્યારે સંયુક્ત થાય છે, ત્યારે તેઓ એન્જિનને લોભી રીતે બાકીની આખી સ્ટ્રિંગનો વપરાશ કરવા અને પછી બાકીની પેટર્ન મેચ થઈ શકે છે કે કેમ તે જોવા માટે એક પછી એક અક્ષર બેકટ્રેક કરવાનો નિર્દેશ આપે છે. આ અત્યંત બિનકાર્યક્ષમ છે.

ખરાબ ઉદાહરણ (HTML ટાઇટલ પાર્સ કરવું):

<title>.*</title>

એક મોટા HTML ડોક્યુમેન્ટ સામે, .* પહેલા ફાઇલના અંત સુધી બધું મેચ કરશે. પછી, તે અક્ષર-દર-અક્ષર બેકટ્રેક કરશે, જ્યાં સુધી તેને અંતિમ </title> ન મળે. આ ઘણું બિનજરૂરી કામ છે.

સારું ઉદાહરણ (નકારાત્મક કેરેક્ટર ક્લાસનો ઉપયોગ કરીને):

<title>[^<]*</title>

આ સંસ્કરણ ઘણું વધુ કાર્યક્ષમ છે. નકારાત્મક કેરેક્ટર ક્લાસ [^<]* નો અર્થ છે "એવા કોઈપણ અક્ષરને મેચ કરો જે નથી '<' શૂન્ય કે તેથી વધુ વખત." એન્જિન આગળ વધે છે, અક્ષરોનો વપરાશ કરે છે જ્યાં સુધી તે પ્રથમ '<' પર ન પહોંચે. તેને ક્યારેય બેકટ્રેક કરવાની જરૂર નથી. આ એક સીધો, અસ્પષ્ટ નિર્દેશ છે જે પર્ફોર્મન્સમાં મોટો લાભ આપે છે.

2. ગ્રીડ વિ. લેઝીનેસમાં નિપુણતા મેળવો: પ્રશ્નાર્થ ચિહ્નની શક્તિ

રેજેક્સમાં ક્વોન્ટિફાયર્સ ડિફોલ્ટ રૂપે ગ્રીડી (greedy) હોય છે. આનો અર્થ એ છે કે તેઓ શક્ય તેટલું વધુ ટેક્સ્ટ મેચ કરે છે જ્યારે હજુ પણ એકંદરે પેટર્નને મેચ થવા દે છે.

• ગ્રીડી: *, +, ?, {n,m}

તમે કોઈપણ ક્વોન્ટિફાયરને તેના પછી પ્રશ્નાર્થ ચિહ્ન ઉમેરીને લેઝી (lazy) બનાવી શકો છો. લેઝી ક્વોન્ટિફાયર શક્ય તેટલું ઓછું ટેક્સ્ટ મેચ કરે છે.

• લેઝી: *?, +?, ??, {n,m}?

ઉદાહરણ: બોલ્ડ ટૅગ્સ મેચ કરવા

ઇનપુટ સ્ટ્રિંગ: <b>First</b> and <b>Second</b>

• ગ્રીડી પેટર્ન: <b>.*</b>
  આ મેચ કરશે: <b>First</b> and <b>Second</b>. .* એ લોભી રીતે છેલ્લા </b> સુધી બધું જ વાપરી લીધું.
• લેઝી પેટર્ન: <b>.*?</b>
  આ પ્રથમ પ્રયાસમાં <b>First</b> મેચ કરશે, અને જો તમે ફરીથી શોધશો તો <b>Second</b> મેચ કરશે. .*? એ પેટર્નના બાકીના ભાગ (</b>) ને મેચ થવા દેવા માટે જરૂરી ન્યૂનતમ અક્ષરો મેચ કર્યા.

જ્યારે લેઝીનેસ અમુક મેચિંગ સમસ્યાઓ હલ કરી શકે છે, તે પર્ફોર્મન્સ માટે રામબાણ ઈલાજ નથી. લેઝી મેચના દરેક પગલા માટે એન્જિનને તપાસવાની જરૂર પડે છે કે પેટર્નનો આગલો ભાગ મેચ થાય છે કે નહીં. અત્યંત વિશિષ્ટ પેટર્ન (જેમ કે અગાઉના મુદ્દામાંથી નકારાત્મક કેરેક્ટર ક્લાસ) ઘણીવાર લેઝી પેટર્ન કરતાં વધુ ઝડપી હોય છે.

પર્ફોર્મન્સ ક્રમ (સૌથી ઝડપીથી સૌથી ધીમું):

1. વિશિષ્ટ/નકારાત્મક કેરેક્ટર ક્લાસ: <b>[^<]*</b>
2. લેઝી ક્વોન્ટિફાયર: <b>.*?</b>
3. ઘણા બધા બેકટ્રેકિંગ સાથે ગ્રીડી ક્વોન્ટિફાયર: <b>.*</b>

3. કેટાસ્ટ્રોફિક બેકટ્રેકિંગ ટાળો: નેસ્ટેડ ક્વોન્ટિફાયર્સને કાબૂમાં રાખો

જેમ આપણે પ્રારંભિક ઉદાહરણમાં જોયું તેમ, કેટાસ્ટ્રોફિક બેકટ્રેકિંગનું સીધું કારણ એક એવી પેટર્ન છે જ્યાં એક ક્વોન્ટિફાઇડ ગ્રુપમાં બીજું ક્વોન્ટિફાયર હોય છે જે સમાન ટેક્સ્ટને મેચ કરી શકે છે. એન્જિનને ઇનપુટ સ્ટ્રિંગને વિભાજીત કરવાની બહુવિધ રીતો સાથેની એક અસ્પષ્ટ પરિસ્થિતિનો સામનો કરવો પડે છે.

સમસ્યારૂપ પેટર્ન્સ:

• (a+)+
• (a*)*
• (a|aa)+
• (a|b)* જ્યાં ઇનપુટ સ્ટ્રિંગમાં ઘણા 'a' અને 'b' હોય છે.

ઉકેલ એ છે કે પેટર્નને અસ્પષ્ટ બનાવવી. તમે ખાતરી કરવા માંગો છો કે આપેલ સ્ટ્રિંગને મેચ કરવા માટે એન્જિન માટે માત્ર એક જ રસ્તો છે.

4. એટોમિક ગ્રુપ્સ અને પોસેસિવ ક્વોન્ટિફાયર્સને અપનાવો

આ તમારા એક્સપ્રેશન્સમાંથી બેકટ્રેકિંગને દૂર કરવા માટેની સૌથી શક્તિશાળી તકનીકોમાંની એક છે. એટોમિક ગ્રુપ્સ અને પોસેસિવ ક્વોન્ટિફાયર્સ એન્જિનને કહે છે: "એકવાર તમે પેટર્નના આ ભાગને મેચ કરી લો, પછી ક્યારેય કોઈપણ અક્ષર પાછો ન આપો. આ એક્સપ્રેશનમાં બેકટ્રેક ન કરો."

પોસેસિવ ક્વોન્ટિફાયર્સ

પોસેસિવ ક્વોન્ટિફાયર સામાન્ય ક્વોન્ટિફાયર પછી + ઉમેરીને બનાવવામાં આવે છે (દા.ત., *+, ++, ?+, {n,m}+). તેઓ Java, PCRE (PHP, R), અને Ruby જેવા એન્જિન્સ દ્વારા સપોર્ટેડ છે.

ઉદાહરણ: 'a' પછી આવતી સંખ્યાને મેચ કરવી

ઇનપુટ સ્ટ્રિંગ: 12345

• સામાન્ય રેજેક્સ: \d+a
\d+ એ "12345" ને મેચ કરે છે. પછી, એન્જિન 'a' ને મેચ કરવાનો પ્રયાસ કરે છે અને નિષ્ફળ જાય છે. તે બેકટ્રેક કરે છે, તેથી \d+ હવે "1234" ને મેચ કરે છે, અને તે '5' ની સામે 'a' ને મેચ કરવાનો પ્રયાસ કરે છે. તે આ ત્યાં સુધી ચાલુ રાખે છે જ્યાં સુધી \d+ તેના બધા અક્ષરો છોડી ન દે. નિષ્ફળ થવા માટે આ ઘણું કામ છે.
• પોસેસિવ રેજેક્સ: \d++a
\d++ પોસેસિવ રીતે "12345" ને મેચ કરે છે. પછી એન્જિન 'a' ને મેચ કરવાનો પ્રયાસ કરે છે અને નિષ્ફળ જાય છે. કારણ કે ક્વોન્ટિફાયર પોસેસિવ હતું, એન્જિનને \d++ ભાગમાં બેકટ્રેક કરવાની મનાઈ છે. તે તરત જ નિષ્ફળ જાય છે. આને 'ઝડપથી નિષ્ફળ થવું' (failing fast) કહેવાય છે અને તે અત્યંત કાર્યક્ષમ છે.

એટોમિક ગ્રુપ્સ

એટોમિક ગ્રુપ્સની સિન્ટેક્સ (?>...) છે અને તે પોસેસિવ ક્વોન્ટિફાયર્સ કરતાં વધુ વ્યાપક રીતે સપોર્ટેડ છે (દા.ત., .NET, Python ના નવા `regex` મોડ્યુલમાં). તેઓ પોસેસિવ ક્વોન્ટિફાયર્સની જેમ જ વર્તે છે પરંતુ આખા ગ્રુપ પર લાગુ પડે છે.

રેજેક્સ (?>\d+)a એ \d++a ની કાર્યાત્મક રીતે સમકક્ષ છે. તમે મૂળ કેટાસ્ટ્રોફિક બેકટ્રેકિંગ સમસ્યાને હલ કરવા માટે એટોમિક ગ્રુપ્સનો ઉપયોગ કરી શકો છો:

મૂળ સમસ્યા: (a+)+
એટોમિક ઉકેલ: ((?>a+))+

હવે, જ્યારે આંતરિક ગ્રુપ (?>a+) 'a' ની શ્રેણીને મેચ કરે છે, ત્યારે તે તેમને બાહ્ય ગ્રુપ દ્વારા ફરીથી પ્રયાસ કરવા માટે ક્યારેય છોડશે નહીં. તે અસ્પષ્ટતા દૂર કરે છે અને ઘાતાંકીય બેકટ્રેકિંગને અટકાવે છે.

5. વૈકલ્પિકોનો ક્રમ મહત્ત્વપૂર્ણ છે

જ્યારે NFA એન્જિન વૈકલ્પિક (`|` પાઇપનો ઉપયોગ કરીને) નો સામનો કરે છે, ત્યારે તે વિકલ્પોને ડાબેથી જમણે પ્રયાસ કરે છે. આનો અર્થ એ છે કે તમારે સૌથી સંભવિત વિકલ્પને પ્રથમ મૂકવો જોઈએ.

ઉદાહરણ: કમાન્ડનું પાર્સિંગ

કલ્પના કરો કે તમે કમાન્ડ્સનું પાર્સિંગ કરી રહ્યા છો, અને તમે જાણો છો કે `GET` કમાન્ડ 80% વખત આવે છે, `SET` 15% વખત, અને `DELETE` 5% વખત.

ઓછું કાર્યક્ષમ: ^(DELETE|SET|GET)
તમારા 80% ઇનપુટ્સ પર, એન્જિન પહેલા `DELETE` ને મેચ કરવાનો પ્રયાસ કરશે, નિષ્ફળ જશે, બેકટ્રેક કરશે, `SET` ને મેચ કરવાનો પ્રયાસ કરશે, નિષ્ફળ જશે, બેકટ્રેક કરશે, અને અંતે `GET` સાથે સફળ થશે.

વધુ કાર્યક્ષમ: ^(GET|SET|DELETE)
હવે, 80% વખત, એન્જિનને પહેલા જ પ્રયાસમાં મેચ મળે છે. લાખો લાઈનો પર પ્રક્રિયા કરતી વખતે આ નાનો ફેરફાર નોંધપાત્ર અસર કરી શકે છે.

6. જ્યારે તમારે કેપ્ચરની જરૂર ન હોય ત્યારે નોન-કેપ્ચરિંગ ગ્રુપ્સનો ઉપયોગ કરો

રેજેક્સમાં કૌંસ (...) બે વસ્તુઓ કરે છે: તેઓ સબ-પેટર્નને ગ્રુપ કરે છે, અને તેઓ તે સબ-પેટર્ન સાથે મેચ થયેલા ટેક્સ્ટને કેપ્ચર કરે છે. આ કેપ્ચર થયેલ ટેક્સ્ટ પછીના ઉપયોગ માટે મેમરીમાં સંગ્રહિત થાય છે (દા.ત., `\1` જેવા બેકરેફરન્સમાં અથવા કોલિંગ કોડ દ્વારા એક્સટ્રેક્શન માટે). આ સંગ્રહમાં નાનો પરંતુ માપી શકાય તેવો ઓવરહેડ હોય છે.

જો તમને ફક્ત ગ્રુપિંગ વર્તનની જરૂર હોય પરંતુ ટેક્સ્ટને કેપ્ચર કરવાની જરૂર ન હોય, તો નોન-કેપ્ચરિંગ ગ્રુપનો ઉપયોગ કરો: (?:...).

કેપ્ચરિંગ: (https?|ftp)://([^/]+)
આ "http" અને ડોમેન નામને અલગથી કેપ્ચર કરે છે.

નોન-કેપ્ચરિંગ: (?:https?|ftp)://([^/]+)
અહીં, આપણે હજી પણ https?|ftp ને ગ્રુપ કરીએ છીએ જેથી :// યોગ્ય રીતે લાગુ થાય, પરંતુ આપણે મેચ થયેલ પ્રોટોકોલને સંગ્રહિત કરતા નથી. જો તમને ફક્ત ડોમેન નામ (જે ગ્રુપ 1 માં છે) એક્સટ્રેક્ટ કરવામાં રસ હોય તો આ સહેજ વધુ કાર્યક્ષમ છે.

એડવાન્સ તકનીકો અને એન્જિન-વિશિષ્ટ ટિપ્સ

લુકઅરાઉન્ડ્સ: શક્તિશાળી પરંતુ સાવચેતી સાથે ઉપયોગ કરો

લુકઅરાઉન્ડ્સ (લુકઅહેડ (?=...), (?!...) અને લુકબિહાઇન્ડ (?<=...), (?) ઝીરો-વિડ્થ એસર્શન્સ છે. તેઓ કોઈપણ અક્ષરોનો વપરાશ કર્યા વિના શરત તપાસે છે. સંદર્ભને માન્ય કરવા માટે આ ખૂબ કાર્યક્ષમ હોઈ શકે છે.

import re

# રેજેક્સને એકવાર કમ્પાઇલ કરો
log_pattern = re.compile(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})')

for line in log_file:
    # કમ્પાઇલ કરેલ ઓબ્જેક્ટનો ઉપયોગ કરો
    match = log_pattern.search(line)
    if match:
        print(match.group(1))